RGB zu YCbCr

Fuchs aus dem Wald

Wow danke. Man das sollte man ja eigentlich selber wissen. xD

Also ich hab jetzt eine Abtast Form von 4:2:0
Würde das heißen ich muss Cb und Cr x4 nehmen?
Ich mein es sind ja immer 4 Y-Blöcke und jeweils ein Cb-Block udn Cr-Block.

Gleich noch eine Frage:
- Was heißt verdoppeln der Größe? Aus einer 8x8 Matrix zwei gleiche 8x8 Matrizen?

hustbaer

Ne guck mal...

Jede 8x8 Matrix ist ein kleines 8x8 Rechteck aus dem vollständigen Bild.
Nur dass du nicht ein farbiges Bild hast, sondern 3 monochrome.
Je eins für Y, Cr und Cb.

Das Y Bild hat sagen wir mal 256x256 Pixel, besteht also aus 32x32 Rechtcken von denen jedes 8x8 Pixel gross ist.
Die Cb und Cr Bilder sind nur 128x128 Pixel gross, bestehen also aus 16x16 Rechtcken von denen jedes 8x8 Pixel gross ist.

Um zu einem farbigen Bild zu kommen musst du nun die Y, Cb und Cr Bilder übereinanderlegen. Die Cb und Cr Bilder sind aber zu klein, das heisst du musst sie vergrössern (Resamplen). Und zwar von 128x128 auf 256x256, also einfach Breite und Höhe verdoppeln.
Die einfachste Variante, die zum Testen erstmal reichen sollte, ist jeden Pixel einfach in ein 2x2 Quadrat mit genau dieser Farbe zu verwandeln.

Ein Set aus 4 Y Blöcken + je einem Cb und Cr Block enthält also die Informationen die nötig sind um ein 16x16 Rechteck des original Bildes zu rekonstruieren.

Wobei ich es wie gesagt nicht auf Block-Ebene machen würde, sondern erst das gesamte "Y Bild", das gesamte "Cb Bild" und das gesamte "Cr Bild" aufbauen, dann die Cb und Cr "Bilder" vergrössern, und dann YCbCr -> RGB konvertieren.

Fuchs aus dem Wald

Vielen dank.

D.h. also das wenn ich ein 128x128 auf 256x256 vergrößer, ist das sozusagen noch mal ein 128x128 dazu aber leeres? Wie hier zu sehen ist im oberen Teil.

hustbaer

Fuchs aus dem Wald schrieb:

Vielen dank.

D.h. also das wenn ich ein 128x128 auf 256x256 vergrößer, ist das sozusagen noch mal ein 128x128 dazu aber leeres?

Den Satz versteh ich nicht. Muss man aber glaub ich auch nicht verstehen.

Wie hier zu sehen ist im oberen Teil.

Ja.
Du sollst einfach das

ABCDEFGH
12345678
........

in das verwandeln:

AABBCCDDEEFFGGHH
AABBCCDDEEFFGGHH
1122334455667788
1122334455667788
................
................

Ich versteh nicht was daran so schwer zu verstehen ist.
Aufblasen halt. Vergrössern. Grösser machen. Resampeln. Skalieren.

Fuchs aus dem Wald

Ich dachte so:

ABC

A B C

Also doch noch mal genau das gleiche wie ich es schon gesagt hatte dazu...

hustbaer

Hä?

Wenn A == 100 und B == 200, was ist dann " "?

Fuchs aus dem Wald

Ja ich sag ich hab falsch gedacht. Aber hatte es erst richtig doch du hast mich noch mal verwirrt.

Aus einer 8x8 Matrix zwei gleiche 8x8 Matrizen?

Naja ich hab es jedenfalls verstanden. Danke dir.

Fuchs aus dem Wald

Hat vielleicht noch jemand mal eine Idee wie ich das vergleichen der codewörter beschleunigen könnte?

void SCANS::huffsel(Huffman* keeper, const char* sos, int j){ 
  bool up       = true;
  Huffman* last = keeper;
  for(int k = 0; k<8; ++k){
    for(int l = 0; l<8; ++l){
      keeper = last;
      if( k != 0 && l != 0){
        while(keeper){
          up = huffcalc(keeper, sos, j);
          if(up){
            if(keeper->rle){
              helper(k, l);
            }
            matrixBuff[k][l] = keeper->category;
            keeper = 0;
          }else{
            keeper = keeper->next;
          }//else
        }//while
        ++j;
      }//if
    }//l
  }//k
}

bool SCANS::huffcalc(Huffman* keeper, const char* sos, int j){
  uint16_t buff = 0;
  buff = (uint8_t)sos[j] & BITMASK;
  if(buff == keeper->codeword){
    return true;
  }else{
    buff = (buff << 8) | (uint8_t)sos[j+1];
    for(int o = 0; o<16; ++o){
      if(buff == keeper->codeword){
        return true;
      }
      if(buff == 0) { o = 16; }
      buff = buff >> 1;
    }
    return false;
  }
}

So wie es jetzt ist ruft huffsel() für jedes Codewort huffcalc() auf. Und zwar für jede Stelle an der ich grade bin wird die ganze Tabelle durchlaufen.

Macht mich ruhig fertig den es ist wirklich schrecklich lahm. (3milarden prozesse in der huffcalc())

EDIT:
Ach so hier noch der helper:

void SCANS::helper(int &k, int &l){
  int counter = 0;
  for(int k; k<8; ++k){
    for(int l; l<8; ++l){
      if(keeper->rle == counter){
        return;
      }else{
        matrixBuff[k][l] = 0;
        ++counter;
      }//if
    }//l
  }//k
}

hustbaer

Huffman Dekodierung ist ja nicht JPEG-spezifisch, da findest du genug Infos im Netz.
Auch was die Üblichen Optimierungen angeht.

Im Prinzip kannst du hergehen und Tables aufbauen wo du für alle möglichen N-Bit Kombinationen abspeicherst:
* Ja, für diese Kombination gibt es komplettes Codewort das mit den ersten Bit M Bits der Kombination anfängt
oder
* Nein, es gibt kein komplettes Codewort das mit den ersten Bit M Bits der Kombination anfängt

Ganz grob skizziert:

HuffmanInputStream h;
int codeLengthTable[1024] = {};
//...
// h Initialisieren, codeLengthTable anfüllen
//...
while (h.remainingBitCount >= 10)
{
    int v = h.first10Bits;
    int codeLength = codeLengthTable[v];
    if (codeLength == 0)
    {
        // Mist, langsame Variante
        // ...
        // ...
    }
    else
    {
        // Hui, getroffen
        // 'codeLength' Bits aus 'v' rausnehmen und damit
        // das auszugebende Symbol nachschlagen
        h.ConsumeBits(codeLength);
    }
}

while (h.remainingBitCount >= 10)
{
    // Langsame Variante
}

Also wenn z.B. "10" ein Code ist, dann füllst du alle 256 Einträge in codeLengthTable die mit "10" anfangen mit 2.

Das auszugebende Symbol schlägst du natürlich auch in einem Table nach.
Dadurch musst du für die häufigsten Symbole schonmal den Baum nicht durchgehen. Bits rumschieben muss man natürlich immer noch.

Das lässt sich vermutlich auch über Tables optimieren, aber da ich das selbst noch nie gemacht habe, und es wie gesagt genügend Material dazu online geben sollte... darfst du das selbst nachlesen.

Fuchs aus dem Wald

Vielen danke.

Also mein Decoder ist jetzt fertig muss halt noch debuggen. Es läuft zwar aber noch ist das nicht richtig.

Es ist soweit das ich sagen kann, ha! Und ich hab es doch so weit geschafft!!

hustbaer danke noch mal für deine viele Hilfe.

Wenn ich zum Encoder komme meld ich mich bestimmt wieder.

hustbaer

Fuchs aus dem Wald schrieb:

Wenn ich zum Encoder komme meld ich mich bestimmt wieder.

Einfach den Decoder ausdrucken und verkehrt herum wieder einscannen

Fuchs aus dem Wald

Hehe alles klar wird gemacht

Wenn das nicht läuft bist du schuld!! :p

hustbaer

Ist das
http://www.mathematik.de/spudema/spudema_beitraege/beitraege/rooch/nresumee.html
deine Arbeit?
Falls ja...

Statt eine Farbinformation über Rot-, Grün- und Blauwerte darzustellen, wird sie durch Helligkeit, Farbton, Farbsättigung (YUV), bzw. durch Helligkeit, Abweichungen vom Grau- zum Blauwert und Abweichung vom Grau- zum Rotwert (YCbCr) ausgedrückt.

Det stimmt so nicht.
YUV ist im Prinzip das selbe wie YCbCr. Wenns analog ist sagt man YUV und wenns digital ist YCbCr.

http://en.wikipedia.org/wiki/YUV
http://en.wikipedia.org/wiki/YCbCr

Was du meinst ist HSV (Hue, Saturation, Value) bzw. bestenfalls noch HSL (Hue, Saturation, Luminance).

Fuchs aus dem Wald

Nein ist nicht meine arbeit ich wollte nur einen Link zu meinem Thema in die sign packen.

Fuchs aus dem Wald

Frage:
Wie kann ich mir mein decodiertes Bild anschauen?? Ich hab jetzt die umgerechneten RGB werte in einem Vektor. Muss da noch was zu oder kann ich das nun so anschauen, wenn ja wie? ^^
Danke

hustbaer

Kommt drauf an mit welcher Sprache/OS/Framework/... du arbeitest.

Eine halbwegs einfache Möglichkeit die überall geht ist ein BMP File zu schreiben. Das Format ist ausreichend einfach dass man das Abspeichern in sagen wir mal 1/2 bis 1 Stunde programmiert hat, und quasi jedes Programm kann die Dinger aufmachen.

Fuchs aus dem Wald

Sprache: C++
Arbeiten tue ich in KDevelop 4

Ok danke für den Tipp werde ich mir mal anschauen.

Ethon

Oder nimm einfach SFML. Ein sf::Image erzeugen, Pixel setzen, saveToFile, fertig.
http://www.sfml-dev.org/documentation/2.0/classsf_1_1Image.php